package com.lxl.common;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @Description 公共工具类
 * @Date 2021/11/29 16:26
 * @Created by LXLDEMO
 */
public class CommonUtil {
    public static final String POINT = ".";


    /**
     * 工具类，不允许new对象
     */
    private CommonUtil(){

    }

    /**
     * double转BigDecimal
     * @param value 非空
     * @return
     */
    public static BigDecimal double2BigDecimal(double value){
        return new BigDecimal(String.valueOf(value));
    }

    /**
     * 判断字符是否为数字类型
     * @param str
     * @return
     */
    public static boolean isNumeric(String str){
        Pattern pattern = Pattern.compile("-?[0-9]+.?[0-9]+");
        Matcher isNum = pattern.matcher(str);
        if (!isNum.matches()){
            return false;
        }
        return true;
    }

    /**
     * 判断object对象是否为空
     * @param object
     * @return
     */
    public static boolean isBlank(final Object object){
        return null == object || "".equals(object);
    }

    /**
     * 判定map中的key对应的value为空，则付给缺省值
     * @param map       map对象
     * @param key       map对象的key
     * @param defaultValue     map对象默认value
     */
    public static void defaultValue4Map(final Map map, final Object key, final Object defaultValue){
        if (isBlank(map.get(key))){
            map.put(key,defaultValue);
        }
    }

    /**
     * 判断key是否为空，空则赋给缺省值value，否则返回自身字符串
     * @param key       map对象的key
     * @param defaultValue     map对象的默认value
     * @return
     */
    public static String defaultValue4Object(final Object key, final String defaultValue){
        return isEmpty(key) ? defaultValue : key.toString();
    }

    /**
     * 去掉后面无用的0
     * @param str
     * @return
     */
    public static String removeZero(String str){
        if (str.indexOf(POINT) > 0){
            //正则表达式
            str = str.replaceAll("0+?$", "");//去掉后面无用的零
            str = str.replaceAll("[.]$", "");//如小数点后面全是零则去掉小数点
        }
        return str;
    }

    /**
     * 对象中是否包含元素
     *
     * @param obj       对象
     * @param element   元素
     * @return          是否包含
     */
    public static boolean isContain(Object obj, Object element) {
        if (obj == null) {
            return false;
        }
        if (obj instanceof String) {
            if (null == element) {
                return false;
            }
            return ((String) obj).contains(element.toString());
        }
        if (obj instanceof Collection) {
            return ((Collection<?>) obj).contains(element);
        }
        if (obj instanceof Map) {
            return ((Map<?, ?>) obj).values().contains(element);
        }

        if (obj instanceof Iterator) {
            Iterator<?> iter = (Iterator<?>) obj;
            while (iter.hasNext()) {
                Object o = iter.next();
                if (equals(o, element)) {
                    return true;
                }
            }
            return false;
        }
        if (obj instanceof Enumeration) {
            Enumeration<?> enumeration = (Enumeration<?>) obj;
            while (enumeration.hasMoreElements()) {
                Object o = enumeration.nextElement();
                if (equals(o, element)) {
                    return true;
                }
            }
            return false;
        }
        if (obj.getClass().isArray() == true) {
            int len = Array.getLength(obj);
            for (int i = 0; i < len; i++) {
                Object o = Array.get(obj, i);
                if (equals(o, element)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 比较两个对象是否相等。
     * 相同的条件有两个，满足其一即可：
     *    1. obj1 == null && obj2 == null;
     *    2. obj1.equals(obj2)
     * @param obj1  对象1
     * @param obj2  对象2
     * @return 是否相等
     */
    public static boolean equals(Object obj1, Object obj2) {
        return (null != obj1) ? (obj1.equals(obj2)) : (null == obj2);
    }

    /**
     * 判断字符串中是否包含字母
     * @param str 待检验的原始字符串
     * @return 返回是否包含
     */
    public static boolean isContainAlphabet(String str) {
        String regex=".*[a-zA-Z]+.*";
        Matcher m = Pattern.compile(regex).matcher(str);
        return m.matches();
    }

    /**
     * 从List<Map<>>中取一个字段数据，放在list中返回
     * @param paramList
     * @param key       map中对应的字段
     * @return
     */
    public static List<String> getListByKeyFromListMap(List<Map<String, Object>> paramList, String key ){
        List<String> list4Key = new ArrayList<>();
        for (Map<String, Object> map : paramList ) {
            list4Key.add(map.get(key).toString());
        }
        return list4Key;
    }

    /**
     * 将List<Map<String, Object>> 根据 key 转换成Map<String,Map<String,Object>>
     * @param dataList 查询数据结果列表
     * @param key      数据结果中的key，对应图表的横轴，图例等
     * @return 组装结果
     */
    public static Map<String, Map<String, Object>> listMap2MapMap(List<Map<String, Object>> dataList, String key) {
        //key为省份，value中map对象，key为指标id，value为map对象，key为数据类型，value为数据值
        Map<String, Map<String, Object>> resultMap = new HashMap<>();
        if (null != dataList && dataList.size() > 0) {
            for (Map<String, Object> data : dataList) {
                if (null == data.get(key)) {
                    continue;
                }
                String dataKey = data.get(key).toString();
                resultMap.put(dataKey, data);
            }
        }
        return resultMap;
    }

    /**
     * 将List<Map<String, Object>> 转换为 Map<String,List<Map<String,Object>>>
     * @param dataList source
     * @param key 外层Mapkey
     * @return
     */
    public Map<String,List<Map<String,Object>>> listMap2MapListMap(List<Map<String, Object>> dataList,String key){
        Map<String,List<Map<String,Object>>> resultMap = new LinkedHashMap<String,List<Map<String,Object>>>();
        if (dataList != null && dataList.size() > 0) {
            for (Map<String, Object> data : dataList) {
                if (null != key && null == data.get(key)) {
                    continue;
                }
                String dataKey = data.get(key).toString();
                List<Map<String,Object>> dataKeyList = resultMap.get(dataKey);
                if (null == dataKeyList) {
                    dataKeyList = new ArrayList<>();
                }
                dataKeyList.add(data);
                resultMap.put(dataKey, dataKeyList);
            }
        }
        return resultMap;
    }

    /**
     * 对象是否为空
     *
     * @param o  String,List,Map,Object[],int[],long[]
     * @return
     */
    public static boolean isEmpty(Object o) {
        if (o == null) {
            return true;
        }
        if (o instanceof String) {
            if ("".equals(o.toString()) || "NULL".equals(o.toString()) || "null".equals(o.toString())) {
                return true;
            }
        } else if (o instanceof List) {
            if (((List) o).size() == 0) {
                return true;
            }
        } else if (o instanceof Map) {
            if (((Map) o).size() == 0) {
                return true;
            }
        } else if (o instanceof Set) {
            if (((Set) o).size() == 0) {
                return true;
            }
        } else if (o instanceof Object[]) {
            if (((Object[]) o).length == 0) {
                return true;
            }
        } else if (o instanceof int[]) {
            if (((int[]) o).length == 0) {
                return true;
            }
        } else if (o instanceof long[]) {
            if (((long[]) o).length == 0) {
                return true;
            }
        }
        return false;
    }


}
